JavaScript വികസന പരിസ്ഥിതി: Docker കണ്ടെയ്‌നർ കോൺഫിഗറേഷൻ

ഇന്നത്തെ അതിവേഗ സോഫ്റ്റ്‌വെയർ വികസന രംഗത്ത്, സ്ഥിരതയുള്ളതും പുനരുൽപ്പാദിപ്പിക്കാവുന്നതുമായ വികസന പരിസ്ഥിതി നിലനിർത്തുന്നത് വളരെ പ്രധാനമാണ്. വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ, വിവിധ സോഫ്റ്റ്‌വെയർ പതിപ്പുകൾ, വൈരുദ്ധ്യമുള്ള ഡിപൻഡൻസികൾ എന്നിവ "എൻ്റെ മെഷീനിൽ ഇത് പ്രവർത്തിക്കുന്നു" എന്ന വിരസമായ അവസ്ഥയിലേക്ക് നയിച്ചേക്കാം. Docker, ഒരു പ്രമുഖ കണ്ടെയ്‌നറൈസേഷൻ പ്ലാറ്റ്ഫോം, ഈ പ്രശ്നത്തിന് ശക്തമായ പരിഹാരം നൽകുന്നു, ഡെവലപ്പർമാരെ അവരുടെ ആപ്ലിക്കേഷനും അതിൻ്റെ ഡിപൻഡൻസികളും ഒരൊറ്റ, വേർതിരിച്ച ഘടകമായി പാക്കേജ് ചെയ്യാൻ അനുവദിക്കുന്നു.

Docker കണ്ടെയ്‌നറുകൾ ഉപയോഗിച്ച് ശക്തവും സ്ഥിരതയുള്ളതുമായ JavaScript വികസന പരിസ്ഥിതി സജ്ജീകരിക്കുന്നതിനുള്ള പ്രക്രിയയിലൂടെ ഈ ഗൈഡ് നിങ്ങളെ കൊണ്ടുപോകും. അടിസ്ഥാന സജ്ജീകരണം മുതൽ നൂതന കോൺഫിഗറേഷനുകൾ വരെ ഞങ്ങൾ എല്ലാം ഉൾക്കൊള്ളും, നിങ്ങളുടെ JavaScript പ്രോജക്റ്റുകൾക്കായി സുഗമവും കാര്യക്ഷമവുമായ വർക്ക്ഫ്ലോ ഉറപ്പാക്കും, നിങ്ങളുടെ ടീമിന്റെ വിവിധ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളെ ആശ്രയിക്കാതെ.

എന്തുകൊണ്ട് JavaScript വികസനത്തിന് Docker ഉപയോഗിക്കണം?

പ്രത്യേകതകളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, നിങ്ങളുടെ JavaScript വികസന പരിസ്ഥിതിക്ക് Docker ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനങ്ങൾ പരിശോധിക്കാം:

• സ്ഥിരത: Docker ഉറപ്പാക്കുന്നു നിങ്ങളുടെ ടീമിലെ എല്ലാവരും ഒരേ പരിസ്ഥിതിയാണ് ഉപയോഗിക്കുന്നതെന്ന്, അനുയോജ്യത പ്രശ്നങ്ങൾ ഇല്ലാതാക്കുകയും പരിസ്ഥിതിയിലെ വ്യത്യാസങ്ങൾ കാരണം ഉണ്ടാകുന്ന ബഗുകളുടെ സാധ്യത കുറയ്ക്കുകയും ചെയ്യുന്നു. ഇത് പ്രത്യേകിച്ച് ഭൂമിശാസ്ത്രപരമായി വിതരണം ചെയ്ത ടീമുകൾക്ക് പ്രധാനമാണ്.
• വേർതിരിവ്: കണ്ടെയ്‌നറുകൾ ഹോസ്റ്റ് സിസ്റ്റത്തിൽ നിന്ന് വേർതിരിവ് നൽകുന്നു, മറ്റ് പ്രോജക്റ്റുകളുമായുള്ള വൈരുദ്ധ്യങ്ങൾ തടയുകയും നിങ്ങളുടെ ഡിപൻഡൻസികൾ പരസ്പരം ഇടപെടുന്നില്ലെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുന്നു.
• പുനരുൽപ്പാദനക്ഷമത: Docker ഇമേജുകൾ എളുപ്പത്തിൽ പങ്കിടാനും വിന്യസിക്കാനും കഴിയും, ഇത് നിങ്ങളുടെ വികസന പരിസ്ഥിതി വ്യത്യസ്ത മെഷീനുകളിലോ പ്രൊഡക്ഷനിലോ പുനരുൽപ്പാദിപ്പിക്കുന്നത് ലളിതമാക്കുന്നു. പുതിയ ടീം അംഗങ്ങളെ ഓൺബോർഡിംഗ് ചെയ്യുമ്പോഴോ വ്യത്യസ്ത ക്ലൗഡ് പ്രൊവൈഡർമാരിലേക്ക് വിന്യസിക്കുമ്പോഴോ ഇത് വളരെ സഹായകമാണ്.
• പോർട്ടബിലിറ്റി: Windows, macOS, Linux എന്നിവ ഉൾപ്പെടെ Docker പിന്തുണയ്ക്കുന്ന ഏത് പ്ലാറ്റ്ഫോമിലും Docker കണ്ടെയ്‌നറുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും, ഡെവലപ്പർമാർക്ക് അവരുടെ പ്രോജക്റ്റിനെ ബാധിക്കാതെ അവരുടെ ഇഷ്ടപ്പെട്ട ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഉപയോഗിക്കാൻ ഇത് അനുവദിക്കുന്നു.
• ലളിതമായ വിന്യാസം: വികസനത്തിന് ഉപയോഗിക്കുന്ന അതേ Docker ഇമേജ് ടെസ്റ്റിംഗിനും ഉത്പാദനത്തിനും ഉപയോഗിക്കാം, വിന്യാസ പ്രക്രിയ കാര്യക്ഷമമാക്കുകയും പിശകുകളുടെ സാധ്യത കുറയ്ക്കുകയും ചെയ്യുന്നു.

ആവശ്യകതകൾ

തുടങ്ങുന്നതിന് മുമ്പ്, താഴെപ്പറയുന്നവ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക:

• Docker: ഔദ്യോഗിക Docker വെബ്സൈറ്റിൽ (docker.com) നിന്ന് നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിനായി Docker Desktop ഡൗൺലോഡ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക. Docker Desktop Docker Engine, Docker CLI, Docker Compose, മറ്റ് അവശ്യ ഉപകരണങ്ങൾ എന്നിവ ഉൾക്കൊള്ളുന്നു.
• Node.js ഉം npm ഉം (ഓപ്ഷണൽ): കണ്ടെയ്‌നറിനുള്ളിൽ ഇവ ഉള്ളതുകൊണ്ട് നിങ്ങളുടെ ഹോസ്റ്റ് മെഷീനിൽ ഇത് നിർബന്ധമല്ലെങ്കിലും, കണ്ടെയ്‌നറിന് പുറത്തുള്ള ജോലികൾക്കോ നിങ്ങളുടെ പ്രാരംഭ പ്രോജക്റ്റ് ഘടന സജ്ജീകരിക്കുമ്പോഴോ Node.js ഉം npm ഉം പ്രാദേശികമായി ഇൻസ്റ്റാൾ ചെയ്യുന്നത് സഹായകമാകും. നിങ്ങൾക്ക് nodejs.org ൽ നിന്ന് അവ ഡൗൺലോഡ് ചെയ്യാം.
• ഒരു കോഡ് എഡിറ്റർ: നിങ്ങളുടെ ഇഷ്ടപ്പെട്ട കോഡ് എഡിറ്റർ തിരഞ്ഞെടുക്കുക (ഉദാഹരണത്തിന്, VS Code, Sublime Text, Atom). VS Code മികച്ച Docker വിപുലീകരണങ്ങൾ നിങ്ങളുടെ വർക്ക്ഫ്ലോ ലളിതമാക്കാൻ സഹായിക്കും.

അടിസ്ഥാന Dockerfile കോൺഫിഗറേഷൻ

ഏതെങ്കിലും Docker അടിസ്ഥാനമാക്കിയുള്ള പരിസ്ഥിതിയുടെ അടിസ്ഥാനം Dockerfile ആണ്. നിങ്ങളുടെ Docker ഇമേജ് നിർമ്മിക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ ഈ ഫയലിൽ അടങ്ങിയിരിക്കുന്നു. ഒരു Node.js ആപ്ലിക്കേഷനായി ഒരു അടിസ്ഥാന Dockerfile ഉണ്ടാക്കാം:

# ഒരു പാരന്റ് ചിത്രമായി ഔദ്യോഗിക Node.js റൺടൈം ഉപയോഗിക്കുക
FROM node:18-alpine

# കണ്ടെയ്‌നറിനുള്ളിൽ പ്രവർത്തിക്കുന്ന ഡയറക്ടറി സജ്ജമാക്കുക
WORKDIR /app

# package.json ഉം package-lock.json ഉം വർക്കിംഗ് ഡയറക്ടറിയിലേക്ക് പകർത്തുക
COPY package*.json ./

# ആപ്ലിക്കേഷൻ ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുക
RUN npm install

# ആപ്ലിക്കേഷൻ സോഴ്സ് കോഡ് വർക്കിംഗ് ഡയറക്ടറിയിലേക്ക് പകർത്തുക
COPY . .

# പോർട്ട് 3000 പുറത്തേക്ക് തുറന്നുകാട്ടുക (നിങ്ങളുടെ ആപ്ലിക്കേഷൻ വ്യത്യസ്ത പോർട്ട് ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ ക്രമീകരിക്കുക)
EXPOSE 3000

# കണ്ടെയ്‌നർ ആരംഭിക്കുമ്പോൾ പ്രവർത്തിപ്പിക്കേണ്ട കമാൻഡ് നിർവചിക്കുക
CMD ["npm", "start"]

ഓരോ വരിയും നമുക്ക് പരിശോധിക്കാം:

• FROM node:18-alpine: കണ്ടെയ്‌നറിനായുള്ള അടിസ്ഥാന ചിത്രം വ്യക്തമാക്കുന്നു. ഇവിടെ, ഞങ്ങൾ ഔദ്യോഗിക Node.js 18 Alpine ചിത്രം ഉപയോഗിക്കുന്നു, ഇത് ഒരു ഭാരം കുറഞ്ഞ Linux വിതരണമാണ്. Alpine അതിൻ്റെ ചെറിയ വലുപ്പത്തിന് അറിയപ്പെടുന്നു, ഇത് നിങ്ങളുടെ Docker ചിത്രത്തെ മെലിഞ്ഞതാക്കാൻ സഹായിക്കുന്നു. നിങ്ങളുടെ പ്രോജക്റ്റിന് അനുയോജ്യമായ മറ്റ് Node.js പതിപ്പുകൾ പരിഗണിക്കുക.
• WORKDIR /app: കണ്ടെയ്‌നറിനുള്ളിൽ പ്രവർത്തിക്കുന്ന ഡയറക്ടറി /app ആയി സജ്ജമാക്കുന്നു. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ കോഡ് ഇവിടെയായിരിക്കും.
• COPY package*.json ./: package.json ഉം package-lock.json ഉം (അല്ലെങ്കിൽ നിങ്ങൾ Yarn ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ yarn.lock) ഫയലുകൾ വർക്കിംഗ് ഡയറക്ടറിയിലേക്ക് പകർത്തുന്നു. ഈ ഫയലുകൾ ആദ്യം പകർത്തുന്നത് Docker-ന് npm install ഘട്ടം കാഷെ ചെയ്യാൻ അനുവദിക്കുന്നു, ആപ്ലിക്കേഷൻ കോഡ് മാത്രം മാറ്റുമ്പോൾ ബിൽഡ് സമയങ്ങൾ ഗണ്യമായി വേഗത്തിലാക്കുന്നു.
• RUN npm install: package.json ൽ നിർവചിച്ചിട്ടുള്ള ആപ്ലിക്കേഷൻ ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു.
• COPY . .: നിങ്ങളുടെ പ്രാദേശിക പ്രോജക്റ്റ് ഡയറക്ടറിയിൽ നിന്നുള്ള ബാക്കിയുള്ള എല്ലാ ഫയലുകളും ഡയറക്ടറികളും കണ്ടെയ്‌നറിനുള്ളിലെ വർക്കിംഗ് ഡയറക്ടറിയിലേക്ക് പകർത്തുന്നു.
• EXPOSE 3000: പോർട്ട് 3000 തുറന്നുകാട്ടുന്നു, ഇത് ഹോസ്റ്റ് മെഷീനിൽ നിന്ന് ലഭ്യമാക്കുന്നു. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഈ പോർട്ടിൽ കേൾക്കുന്നുണ്ടെങ്കിൽ ഇത് പ്രധാനമാണ്. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ വ്യത്യസ്ത പോർട്ട് ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ പോർട്ട് നമ്പർ ക്രമീകരിക്കുക.
• CMD ["npm", "start"]: കണ്ടെയ്‌നർ ആരംഭിക്കുമ്പോൾ പ്രവർത്തിപ്പിക്കേണ്ട കമാൻഡ് വ്യക്തമാക്കുന്നു. ഇവിടെ, ഞങ്ങൾ npm start ഉപയോഗിക്കുന്നു, ഇത് Node.js ആപ്ലിക്കേഷനുകൾ ആരംഭിക്കുന്നതിനുള്ള ഒരു സാധാരണ കമാൻഡ് ആണ്. നിങ്ങളുടെ package.json ൻ്റെ scripts വിഭാഗത്തിൽ നിർവചിച്ചിട്ടുള്ള കമാൻഡുമായി ഇത് പൊരുത്തപ്പെടുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക.

Docker ഇമേജ് നിർമ്മിക്കുന്നു

നിങ്ങളുടെ Dockerfile ഉണ്ടാക്കിക്കഴിഞ്ഞാൽ, താഴെപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് Docker ഇമേജ് നിർമ്മിക്കാൻ കഴിയും:

docker build -t my-node-app .

ഇവിടെ:

• docker build: ഇമേജുകൾ നിർമ്മിക്കുന്നതിനുള്ള Docker കമാൻഡ്.
• -t my-node-app: ഇമേജിനായുള്ള ടാഗ് (പേര്) വ്യക്തമാക്കുന്നു. നിങ്ങളുടെ ആപ്ലിക്കേഷന് വ്യക്തമായ പേര് നൽകുക.
• .: ബിൽഡ് കോൺടെക്സ്റ്റ് വ്യക്തമാക്കുന്നു, ഇത് നിലവിലെ ഡയറക്ടറി ആണ്. Docker ഇമേജ് നിർമ്മിക്കാൻ ഈ ഡയറക്ടറിയിലെ Dockerfile ഉപയോഗിക്കും.

Docker നിങ്ങളുടെ Dockerfile ലെ നിർദ്ദേശങ്ങൾ പ്രവർത്തിപ്പിച്ച്, ലേയർ ലേയറായി ഇമേജ് നിർമ്മിക്കും. നിങ്ങൾ ആദ്യമായി ഇമേജ് നിർമ്മിക്കുമ്പോൾ, അടിസ്ഥാന ചിത്രം ഡൗൺലോഡ് ചെയ്യാനും ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യാനും കുറച്ച് സമയമെടുത്തേക്കാം. എന്നിരുന്നാലും, Docker ഇടത്തരം ലേയറുകൾ കാഷെ ചെയ്യുന്നതിനാൽ പിന്നീടുള്ള ബിൽഡുകൾ വളരെ വേഗത്തിലായിരിക്കും.

Docker കണ്ടെയ്‌നർ പ്രവർത്തിപ്പിക്കുന്നു

ഇമേജ് നിർമ്മിച്ചതിന് ശേഷം, താഴെപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് അതിൽ നിന്ന് ഒരു കണ്ടെയ്‌നർ പ്രവർത്തിപ്പിക്കാം:

docker run -p 3000:3000 my-node-app

ഇവിടെ:

• docker run: കണ്ടെയ്‌നറുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള Docker കമാൻഡ്.
• -p 3000:3000: ഹോസ്റ്റ് മെഷീനിലെ പോർട്ട് 3000 കണ്ടെയ്‌നറിനുള്ളിലെ പോർട്ട് 3000 ലേക്ക് മാപ്പ് ചെയ്യുന്നു. ഇത് നിങ്ങളുടെ ബ്രൗസർ വഴി localhost:3000 ഉപയോഗിച്ച് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ആക്സസ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ആദ്യത്തെ സംഖ്യ ഹോസ്റ്റ് പോർട്ടാണ്, രണ്ടാമത്തെ സംഖ്യ കണ്ടെയ്‌നർ പോർട്ടാണ്.
• my-node-app: പ്രവർത്തിപ്പിക്കേണ്ട ഇമേജിൻ്റെ പേര്.

നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഇപ്പോൾ Docker കണ്ടെയ്‌നറിനുള്ളിൽ പ്രവർത്തിക്കുന്നുണ്ടാകണം. നിങ്ങളുടെ ബ്രൗസർ തുറന്ന് localhost:3000 (അല്ലെങ്കിൽ നിങ്ങൾ വ്യക്തമാക്കിയ പോർട്ട്) ലേക്ക് നാവിഗേറ്റ് ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് അത് ആക്സസ് ചെയ്യാൻ കഴിയും. നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ സ്വാഗത സ്ക്രീനോ പ്രാഥമിക UI യോ നിങ്ങൾ കാണേണ്ടതാണ്.

Docker Compose ഉപയോഗിക്കുന്നു

ഒന്നിലധികം സേവനങ്ങളുള്ള കൂടുതൽ സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകൾക്ക്, Docker Compose ഒരു വിലപ്പെട്ട ഉപകരണമാണ്. ഇത് ഒരു YAML ഫയൽ ഉപയോഗിച്ച് മൾട്ടി-കണ്ടെയ്‌നർ ആപ്ലിക്കേഷനുകൾ നിർവചിക്കാനും കൈകാര്യം ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്നു. നമ്മുടെ Node.js ആപ്ലിക്കേഷനായി ഒരു docker-compose.yml ഫയൽ ഉണ്ടാക്കാം:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development
    command: npm run dev

ഓരോ ഭാഗവും നമുക്ക് പരിശോധിക്കാം:

• version: "3.9": Docker Compose ഫയൽ ഫോർമാറ്റിന്റെ പതിപ്പ് വ്യക്തമാക്കുന്നു.
• services: നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഉൾക്കൊള്ളുന്ന സേവനങ്ങൾ നിർവചിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾക്ക് app എന്ന പേരിൽ ഒരു സേവനം മാത്രമേയുള്ളൂ.
• build: .: നിലവിലെ ഡയറക്ടറിയിലെ Dockerfile ൽ നിന്ന് ഇമേജ് നിർമ്മിക്കണം എന്ന് വ്യക്തമാക്കുന്നു.
• ports: - "3000:3000": ഹോസ്റ്റ് മെഷീനിലെ പോർട്ട് 3000 കണ്ടെയ്‌നറിനുള്ളിലെ പോർട്ട് 3000 ലേക്ക് മാപ്പ് ചെയ്യുന്നു, ഇത് docker run കമാൻഡിന് സമാനമാണ്.
• volumes: - .:/app: നിങ്ങളുടെ ഹോസ്റ്റ് മെഷീനിലെ നിലവിലെ ഡയറക്ടറി കണ്ടെയ്‌നറിനുള്ളിലെ /app ഡയറക്ടറിയിലേക്ക് മൗണ്ട് ചെയ്യുന്ന ഒരു വോളിയം സൃഷ്ടിക്കുന്നു. ഇത് നിങ്ങളുടെ ഹോസ്റ്റ് മെഷീനിൽ കോഡിൽ മാറ്റങ്ങൾ വരുത്താനും അവ കണ്ടെയ്‌നറിനുള്ളിൽ ഉടനടി പ്രതിഫലിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് ഹോട്ട് റീലോഡിംഗ് സാധ്യമാക്കുന്നു.
• environment: NODE_ENV: development: കണ്ടെയ്‌നറിനുള്ളിൽ NODE_ENV എൻവയോൺമെന്റ് വേരിയബിൾ development ആയി സജ്ജീകരിക്കുന്നു. ഇത് നിങ്ങളുടെ ആപ്ലിക്കേഷനെ ഡെവലപ്‌മെന്റ് മോഡിൽ പ്രവർത്തിക്കാൻ കോൺഫിഗർ ചെയ്യാൻ ഉപയോഗപ്രദമാണ്.
• command: npm run dev: Dockerfile ൽ നിർവചിച്ചിട്ടുള്ള ഡിഫോൾട്ട് കമാൻഡ് ഓവർറൈഡ് ചെയ്യുന്നു. ഇവിടെ, ഞങ്ങൾ npm run dev ഉപയോഗിക്കുന്നു, ഇത് പലപ്പോഴും ഹോട്ട് റീലോഡിംഗുള്ള ഒരു ഡെവലപ്‌മെന്റ് സെർവർ ആരംഭിക്കാൻ ഉപയോഗിക്കുന്നു.

Docker Compose ഉപയോഗിച്ച് ആപ്ലിക്കേഷൻ ആരംഭിക്കുന്നതിന്, docker-compose.yml ഫയൽ അടങ്ങിയ ഡയറക്ടറിയിലേക്ക് നാവിഗേറ്റ് ചെയ്ത് താഴെപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

docker-compose up

Docker Compose ഇമേജ് നിർമ്മിക്കുകയും (ആവശ്യമെങ്കിൽ) കണ്ടെയ്‌നർ ആരംഭിക്കുകയും ചെയ്യും. കണ്ടെയ്‌നറിനെ ഡീറ്റാച്ച്ഡ് മോഡിൽ (പശ്ചാത്തലത്തിൽ) പ്രവർത്തിപ്പിക്കാൻ -d ഫ്ലാഗ് ചേർക്കാം.

അഡ്വാൻസ്ഡ് കോൺഫിഗറേഷൻ ഓപ്ഷനുകൾ

നിങ്ങളുടെ Dockerized JavaScript വികസന പരിസ്ഥിതി മെച്ചപ്പെടുത്തുന്നതിനുള്ള ചില നൂതന കോൺഫിഗറേഷൻ ഓപ്ഷനുകൾ ഇതാ:

1. മൾട്ടി-സ്റ്റേജ് ബിൽഡുകൾ

മൾട്ടി-സ്റ്റേജ് ബിൽഡുകൾ നിങ്ങളുടെ Dockerfile ൽ ഒന്നിലധികം FROM നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഓരോന്നും ഒരു വ്യത്യസ്ത ബിൽഡ് സ്റ്റേജിനെ പ്രതിനിധീകരിക്കുന്നു. ബിൽഡ് പരിസ്ഥിതിയെ റൺടൈം പരിസ്ഥിതിയിൽ നിന്ന് വേർതിരിക്കുന്നതിലൂടെ നിങ്ങളുടെ അന്തിമ ചിത്രത്തിന്റെ വലുപ്പം കുറയ്ക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാണ്.

# സ്റ്റേജ് 1: ആപ്ലിക്കേഷൻ നിർമ്മിക്കുക
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# സ്റ്റേജ് 2: റൺടൈം ചിത്രം സൃഷ്ടിക്കുക
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

ഈ ഉദാഹരണത്തിൽ, ആദ്യ സ്റ്റേജ് (builder) Node.js ഉപയോഗിച്ച് ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നു. രണ്ടാമത്തെ സ്റ്റേജ് നിർമ്മിച്ച ആപ്ലിക്കേഷൻ ഫയലുകൾ നൽകാൻ Nginx ഉപയോഗിക്കുന്നു. ആദ്യ സ്റ്റേജിൽ നിന്നുള്ള നിർമ്മിച്ച ഫയലുകൾ മാത്രമേ രണ്ടാമത്തെ സ്റ്റേജിലേക്ക് പകർത്തിയിട്ടുള്ളൂ, ഇത് ചെറിയതും കൂടുതൽ കാര്യക്ഷമവുമായ ചിത്രം ഉണ്ടാക്കുന്നു.

2. എൻവയോൺമെന്റ് വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു

എൻ്റെ കോഡ് പരിഷ്കരിക്കാതെ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ കോൺഫിഗർ ചെയ്യാൻ എൻവയോൺമെന്റ് വേരിയബിളുകൾ ശക്തമായ മാർഗ്ഗമാണ്. നിങ്ങൾക്ക് അവ നിങ്ങളുടെ docker-compose.yml ഫയലിൽ നിർവചിക്കാനോ -e ഫ്ലാഗ് ഉപയോഗിച്ച് റൺടൈമിൽ കൈമാറാനോ കഴിയും.

services:
  app:
    environment:
      API_URL: "http://api.example.com"

നിങ്ങളുടെ ആപ്ലിക്കേഷനുള്ളിൽ, process.env ഉപയോഗിച്ച് ഈ എൻവയോൺമെന്റ് വേരിയബിളുകൾ ആക്സസ് ചെയ്യാൻ കഴിയും.

const apiUrl = process.env.API_URL;

3. വികസനത്തിന് വോളിയം മൗണ്ടിംഗ്

വോളിയം മൗണ്ടിംഗ് (Docker Compose ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ) വികസനത്തിന് നിർണായകമാണ്, കാരണം നിങ്ങളുടെ ഹോസ്റ്റ് മെഷീനിൽ കോഡിൽ മാറ്റങ്ങൾ വരുത്താനും അവ കണ്ടെയ്‌നറിനുള്ളിൽ ഉടനടി പ്രതിഫലിക്കാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ഓരോ തവണ മാറ്റം വരുത്തുമ്പോഴും ചിത്രം വീണ്ടും നിർമ്മിക്കേണ്ട ആവശ്യം ഇല്ലാതാക്കുന്നു.

4. VS Code ഉപയോഗിച്ച് Debugging

Docker കണ്ടെയ്‌നറുകൾക്കുള്ളിൽ പ്രവർത്തിക്കുന്ന Node.js ആപ്ലിക്കേഷനുകൾ Debugging ചെയ്യുന്നതിന് VS Code മികച്ച പിന്തുണ നൽകുന്നു. പ്രവർത്തിക്കുന്ന കണ്ടെയ്‌നറിലേക്ക് അറ്റാച്ച് ചെയ്യാനും ബ്രേക്ക്‌പോയിന്റുകൾ സജ്ജീകരിക്കാനും വേരിയബിളുകൾ പരിശോധിക്കാനും നിങ്ങളുടെ കോഡിലൂടെ സ്റ്റെപ്പ് ചെയ്യാനും നിങ്ങൾക്ക് VS Code Docker വിപുലീകരണം ഉപയോഗിക്കാം.

ആദ്യം, VS Code ൽ Docker വിപുലീകരണം ഇൻസ്റ്റാൾ ചെയ്യുക. തുടർന്ന് നിങ്ങളുടെ .vscode ഡയറക്ടറിയിൽ താഴെപ്പറയുന്ന കോൺഫിഗറേഷനോടുകൂടിയ ഒരു launch.json ഫയൽ ഉണ്ടാക്കുക:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "Attach to Docker",
      "port": 9229,
      "address": "localhost",
      "remoteRoot": "/app",
      "localRoot": "${workspaceFolder}"
    }
  ]
}

നിങ്ങളുടെ Node.js ആപ്ലിക്കേഷൻ --inspect അല്ലെങ്കിൽ --inspect-brk ഫ്ലാഗ് ഉപയോഗിച്ച് ആരംഭിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഈ ഫ്ലാഗ് ഉൾപ്പെടുത്താൻ നിങ്ങളുടെ docker-compose.yml ഫയൽ പരിഷ്കരിക്കാൻ കഴിയും:

services:
  app:
    command: npm run dev -- --inspect=0.0.0.0:9229

തുടർന്ന്, VS Code ൽ, "Attach to Docker" കോൺഫിഗറേഷൻ തിരഞ്ഞെടുത്ത് Debugging ആരംഭിക്കുക. കണ്ടെയ്‌നറിനുള്ളിൽ പ്രവർത്തിക്കുന്ന നിങ്ങളുടെ കോഡിൽ ബ്രേക്ക്‌പോയിന്റുകൾ സജ്ജീകരിക്കാനും Debugging ചെയ്യാനും നിങ്ങൾക്ക് കഴിയും.

5. ഒരു സ്വകാര്യ npm റെജിസ്ട്രി ഉപയോഗിക്കുന്നു

നിങ്ങൾ സ്വകാര്യ npm പാക്കേജുകളുള്ള ഒരു പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, നിങ്ങളുടെ സ്വകാര്യ npm റെജിസ്ട്രിയുമായി प्रमाणीकरण ചെയ്യുന്നതിന് നിങ്ങളുടെ Docker കണ്ടെയ്‌നർ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്. ഇത് നിങ്ങളുടെ docker-compose.yml ഫയലിൽ NPM_TOKEN എൻവയോൺമെന്റ് വേരിയബിൾ സജ്ജീകരിച്ചുകൊണ്ടോ അല്ലെങ്കിൽ നിങ്ങളുടെ പ്രോജക്റ്റ് ഡയറക്ടറിയിൽ ഒരു .npmrc ഫയൽ ഉണ്ടാക്കി അത് കണ്ടെയ്‌നറിലേക്ക് പകർത്തുന്നതിലൂടെയോ ചെയ്യാൻ കഴിയും.

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
COPY .npmrc .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

`.npmrc` ഫയലിൽ നിങ്ങളുടെ प्रमाणीकरण ടോക്കൺ അടങ്ങിയിരിക്കണം:

//registry.npmjs.org/:_authToken=YOUR_NPM_TOKEN

YOUR_NPM_TOKEN നിങ്ങളുടെ യഥാർത്ഥ npm ടോക്കൺ ഉപയോഗിച്ച് മാറ്റാൻ ഓർക്കുക. ഈ ടോക്കൺ സുരക്ഷിതമായി സൂക്ഷിക്കുക, നിങ്ങളുടെ പൊതു ശേഖരണത്തിൽ അത് സമർപ്പിക്കരുത്.

6. ചിത്രത്തിൻ്റെ വലുപ്പം ഒപ്റ്റിമൈസ് ചെയ്യുന്നു

നിങ്ങളുടെ Docker ചിത്രത്തിന്റെ വലുപ്പം ചെറുതായി നിലനിർത്തുന്നത് വേഗതയേറിയ ബിൽഡ്, വിന്യാസ സമയങ്ങൾക്ക് പ്രധാനമാണ്. ചിത്രത്തിൻ്റെ വലുപ്പം ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനുള്ള ചില നുറുങ്ങുകൾ ഇതാ:

• ഭാരം കുറഞ്ഞ അടിസ്ഥാന ചിത്രം ഉപയോഗിക്കുക, ഉദാഹരണത്തിന് node:alpine.
• ബിൽഡ് പരിസ്ഥിതി റൺടൈം പരിസ്ഥിതിയിൽ നിന്ന് വേർതിരിക്കാൻ മൾട്ടി-സ്റ്റേജ് ബിൽഡുകൾ ഉപയോഗിക്കുക.
• ചിത്രത്തിൽ നിന്ന് അനാവശ്യ ഫയലുകളും ഡയറക്ടറികളും നീക്കം ചെയ്യുക.
• ബിൽഡ് കോൺടെക്സ്റ്റിൽ നിന്ന് ഫയലുകളും ഡയറക്ടറികളും ഒഴിവാക്കാൻ .dockerignore ഫയൽ ഉപയോഗിക്കുക.
• ലേയറുകളുടെ എണ്ണം കുറയ്ക്കുന്നതിന് ഒന്നിലധികം RUN കമാൻഡുകൾ ഒരു കമാൻഡിലേക്ക് സംയോജിപ്പിക്കുക.

ഉദാഹരണം: React ആപ്ലിക്കേഷൻ Dockerize ചെയ്യുന്നു

Create React App ഉപയോഗിച്ച് നിർമ്മിച്ച ഒരു React ആപ്ലിക്കേഷൻ Dockerize ചെയ്യുന്നതിനുള്ള ഒരു പ്രായോഗിക ഉദാഹരണത്തിലൂടെ ഈ ആശയങ്ങൾ വ്യക്തമാക്കാം.

ആദ്യം, Create React App ഉപയോഗിച്ച് ഒരു പുതിയ React ആപ്ലിക്കേഷൻ ഉണ്ടാക്കുക:

npx create-react-app my-react-app
cd my-react-app

തുടർന്ന്, പ്രോജക്റ്റിന്റെ റൂട്ട് ഡയറക്ടറിയിൽ ഒരു Dockerfile ഉണ്ടാക്കുക:

FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

ഒരു docker-compose.yml ഫയൽ ഉണ്ടാക്കുക:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:80"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development

ശ്രദ്ധിക്കുക: Nginx ആപ്ലിക്കേഷൻ പോർട്ട് 80 ൽ നൽകുന്നതിനാൽ ഞങ്ങൾ ഹോസ്റ്റിലെ പോർട്ട് 3000 കണ്ടെയ്‌നറിലെ പോർട്ട് 80 ലേക്ക് മാപ്പ് ചെയ്യുന്നു. നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ കോൺഫിഗറേഷനെ ആശ്രയിച്ച് പോർട്ട് മാപ്പിംഗ് ക്രമീകരിക്കേണ്ടി വന്നേക്കാം.

അവസാനം, ആപ്ലിക്കേഷൻ നിർമ്മിക്കാനും ആരംഭിക്കാനും docker-compose up പ്രവർത്തിപ്പിക്കുക. നിങ്ങളുടെ ബ്രൗസറിൽ localhost:3000 ലേക്ക് നാവിഗേറ്റ് ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് ആപ്ലിക്കേഷൻ ആക്സസ് ചെയ്യാൻ കഴിയും.

സാധാരണ പ്രശ്നങ്ങളും ട്രബിൾഷൂട്ടിംഗും

ശ്രദ്ധാപൂർവമുള്ള കോൺഫിഗറേഷനോടെ പോലും, Docker ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾക്ക് പ്രശ്നങ്ങൾ നേരിടാൻ സാധ്യതയുണ്ട്. ഇതാ ചില സാധാരണ പ്രശ്നങ്ങളും അവയുടെ പരിഹാരങ്ങളും:

• പോർട്ട് വൈരുദ്ധ്യങ്ങൾ: നിങ്ങളുടെ docker-compose.yml അല്ലെങ്കിൽ docker run കമാൻഡിൽ നിങ്ങൾ മാപ്പ് ചെയ്യുന്ന പോർട്ടുകൾ നിങ്ങളുടെ ഹോസ്റ്റ് മെഷീനിലെ മറ്റ് ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുക.
• വോളിയം മൗണ്ടിംഗ് പ്രശ്നങ്ങൾ: നിങ്ങൾ മൗണ്ട് ചെയ്യുന്ന ഫയലുകൾക്കും ഡയറക്ടറികൾക്കും ഉള്ള അനുമതികൾ പരിശോധിക്കുക. ഫയലുകൾ ആക്സസ് ചെയ്യാൻ Docker ക്ക് ആവശ്യമായ അനുമതികൾ ഉണ്ടാകില്ല.
• ഇമേജ് ബിൽഡ് പരാജയങ്ങൾ: പിശകുകൾക്കായി docker build കമാൻഡിൻ്റെ ഔട്ട്പുട്ട് ശ്രദ്ധാപൂർവ്വം പരിശോധിക്കുക. സാധാരണ കാരണങ്ങളിൽ തെറ്റായ Dockerfile സിൻ്റാക്സ്, നഷ്ടപ്പെട്ട ഡിപൻഡൻസികൾ, അല്ലെങ്കിൽ നെറ്റ്‌വർക്ക് പ്രശ്നങ്ങൾ എന്നിവ ഉൾപ്പെടുന്നു.
• കണ്ടെയ്‌നർ ക്രാഷുകൾ: കണ്ടെയ്‌നറിൻ്റെ ലോഗുകൾ കാണാനും ക്രാഷിൻ്റെ കാരണം കണ്ടെത്താനും docker logs കമാൻഡ് ഉപയോഗിക്കുക. സാധാരണ കാരണങ്ങളിൽ ആപ്ലിക്കേഷൻ പിശകുകൾ, നഷ്ടപ്പെട്ട എൻവയോൺമെന്റ് വേരിയബിളുകൾ, അല്ലെങ്കിൽ റിസോഴ്സ് നിയന്ത്രണങ്ങൾ എന്നിവ ഉൾപ്പെടുന്നു.
• മെല്ലിച്ച ബിൽഡ് സമയങ്ങൾ: മൾട്ടി-സ്റ്റേജ് ബിൽഡുകൾ ഉപയോഗിച്ച്, ഡിപൻഡൻസികൾ കാഷെ ചെയ്തുകൊണ്ട്, ലേയറുകളുടെ എണ്ണം കുറച്ചുകൊണ്ട് നിങ്ങളുടെ Dockerfile ഒപ്റ്റിമൈസ് ചെയ്യുക.

ഉപസംഹാരം

Docker സ്ഥിരതയുള്ളതും പുനരുൽപ്പാദിപ്പിക്കാവുന്നതുമായ JavaScript വികസന പരിസ്ഥിതികൾ സൃഷ്ടിക്കുന്നതിന് ശക്തവും ബഹുമുഖവുമായ ഒരു പരിഹാരം നൽകുന്നു. Docker ഉപയോഗിക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് അനുയോജ്യത പ്രശ്നങ്ങൾ ഇല്ലാതാക്കാനും വിന്യാസം ലളിതമാക്കാനും നിങ്ങളുടെ ടീമിലെ എല്ലാവർക്കും ഒരേ പരിസ്ഥിതിയാണ് ഉപയോഗിക്കുന്നതെന്ന് ഉറപ്പാക്കാനും കഴിയും.

ഈ ഗൈഡ് Dockerized JavaScript വികസന പരിസ്ഥിതി സജ്ജീകരിക്കുന്നതിൻ്റെ അടിസ്ഥാനകാര്യങ്ങളും ചില നൂതന കോൺഫിഗറേഷൻ ഓപ്ഷനുകളും ഉൾക്കൊള്ളുന്നു. ഈ ഘട്ടങ്ങൾ പിന്തുടരുന്നതിലൂടെ, നിങ്ങളുടെ JavaScript പ്രോജക്റ്റുകൾക്ക്, അവയുടെ സങ്കീർണ്ണതയോ നിങ്ങളുടെ ടീമിൻ്റെ വലുപ്പമോ പരിഗണിക്കാതെ, ശക്തവും കാര്യക്ഷമവുമായ വർക്ക്ഫ്ലോ സൃഷ്ടിക്കാൻ കഴിയും. Docker സ്വീകരിക്കുക, നിങ്ങളുടെ JavaScript വികസന പ്രക്രിയയുടെ മുഴുവൻ സാധ്യതകളും അനാവരണം ചെയ്യുക.

അടുത്ത ഘട്ടങ്ങൾ:

• നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ മുൻകൂട്ടി നിർമ്മിച്ച ചിത്രങ്ങൾക്കായി Docker Hub കണ്ടെത്തുക.
• മൾട്ടി-കണ്ടെയ്‌നർ ആപ്ലിക്കേഷനുകൾ കൈകാര്യം ചെയ്യുന്നതിന് Docker Compose ൽ ആഴത്തിൽ പോകുക.
• ഉത്പാദന പരിസ്ഥിതികളിൽ Docker കണ്ടെയ്‌നറുകൾ ഓർക്കസ്ട്രേറ്റ് ചെയ്യുന്നതിന് Docker Swarm ഉം Kubernetes ഉം കുറിച്ച് പഠിക്കുക.

ഈ മികച്ച സമ്പ്രദായങ്ങൾ നിങ്ങളുടെ വർക്ക്ഫ്ലോയിൽ ഉൾക്കൊള്ളുന്നതിലൂടെ, നിങ്ങളുടെ JavaScript ആപ്ലിക്കേഷനുകൾക്ക് കൂടുതൽ കാര്യക്ഷമവും, വിശ്വസനീയവും, സ്കേലബിളുമായ വികസന പരിസ്ഥിതി സൃഷ്ടിക്കാൻ കഴിയും, ഇത് ഇന്നത്തെ മത്സരാധിഷ്ഠിത വിപണിയിൽ വിജയം ഉറപ്പാക്കുന്നു.